* Authors: Arjan van de Ven <arjan@fenrus.demon.nl>
* Federico Mena-Quintero <federico@gimp.org>
*
+ * Based on io-gif.c, io-tiff.c and io-png.c
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
+
+/*
+
+Known bugs:
+ * "Indexed" (incl grayscale) sunras files don't work
+ * 1 bpp sunrasfiles don't work
+
+*/
#include <config.h>
#include <stdio.h>
#include <glib.h>
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
#include "gdk-pixbuf.h"
#include "gdk-pixbuf-io.h"
\f
be32_to_cpu() ??
*/
-unsigned int ByteOrder(unsigned int i)
+static unsigned int be32_to_cpu(guint i)
{
unsigned int i2;
i2 =
/*
-OneLineBGR does what it says: Reads one line from file.
+OneLineBGR_buf/file does what it says: Reads one line from file or buffer.
Note: It also changes BGR pixelorder to RGB as libart currently
doesn't support ART_PIX_BGR.
*/
-static OneLineBGR(FILE * f, guint Width, guchar * pixels, gint bpp)
+static void OneLineBGR_buf(guchar * buffer, guint Width, guchar * pixels,
+ guint bpp)
+{
+ guint X;
+
+ memcpy(pixels, buffer, (size_t) (Width * bpp));
+ X = 0;
+ while (X < Width) {
+ guchar Blue;
+ Blue = pixels[X * bpp];
+ pixels[X * bpp] = pixels[X * bpp + 2];
+ pixels[X * bpp + 2] = Blue;
+ X++;
+ }
+}
+
+static void OneLineBGR_file(FILE * f, guint Width, guchar * pixels,
+ guint bpp)
{
- gint result, X;
+ size_t result;
+ guint X;
guchar DummyByte;
- result = fread(pixels, 1, Width * bpp, f);
+ result = fread(pixels, 1, (size_t) (Width * bpp), f);
- g_assert(result == Width * bpp);
- if (((Width * bpp) & 7) != 0) /* Not 16 bit aligned */
- fread(&DummyByte, 1, 1, f);
+ g_assert(result == (size_t) (Width * bpp));
+ if (((Width * bpp) & 1) != 0) /* Not 16 bit aligned */
+ (void) fread(&DummyByte, 1, 1, f);
X = 0;
while (X < Width) {
guchar Blue;
}
}
+static void OneLineMapped_file(FILE * f, guint Width, guchar * pixels,
+ guint bpp, guchar *Map)
+{
+ size_t result;
+ guint X;
+ guchar DummyByte;
+ guchar *buffer;
+
+
+ buffer =g_malloc((size_t) (Width * bpp));
+
+ g_assert(buffer!=NULL);
+
+ result = fread(buffer, 1, (size_t) (Width * bpp), f);
+
+ g_assert(result == (size_t) (Width * bpp));
+
+ if (((Width * bpp) & 1) != 0) /* Not 16 bit aligned */
+ (void) fread(&DummyByte, 1, 1, f);
+ X = 0;
+ while (X < Width) {
+ pixels[X * 3] = Map[buffer[X]*3];
+ pixels[X * 3+1] = Map[buffer[X]*3];
+ pixels[X * 3+2] = Map[buffer[X]*3];
+
+ X++;
+ }
+ g_free(buffer);
+}
+
+static void OneLineMapped_buf(guchar *buffer, guint Width, guchar * pixels,
+ guint bpp,guchar *Map)
+{
+ size_t result;
+ guint X;
+
+ X = 0;
+ while (X < Width) {
+ pixels[X * 3] = Map[buffer[X]*3];
+ pixels[X * 3+1] = Map[buffer[X]*3+1];
+ pixels[X * 3+2] = Map[buffer[X]*3+2];
+
+ X++;
+ }
+}
+
/* Shared library entry point */
GdkPixbuf *image_load(FILE * f)
{
- gint i, bpp, Y;
+ guint bpp;
+ guint Y;
+ size_t i;
guchar *pixels;
+ guchar ColorMap[768];
struct rasterfile Header;
i = fread(&Header, 1, sizeof(Header), f);
g_assert(i == 32);
-
+
+ /* Fill default colormap */
+ for (Y=0;Y<256;Y++) {
+ ColorMap[Y*3+0]=Y;
+ ColorMap[Y*3+1]=Y;
+ ColorMap[Y*3+2]=Y;
+ }
/* Correct the byteorder of the header here */
- Header.width = ByteOrder(Header.width);
- Header.height = ByteOrder(Header.height);
- Header.depth = ByteOrder(Header.depth);
- Header.length = ByteOrder(Header.length);
- Header.type = ByteOrder(Header.type);
- Header.maptype = ByteOrder(Header.maptype);
- Header.maplength = ByteOrder(Header.maplength);
+ Header.width = be32_to_cpu(Header.width);
+ Header.height = be32_to_cpu(Header.height);
+ Header.depth = be32_to_cpu(Header.depth);
+ Header.length = be32_to_cpu(Header.length);
+ Header.type = be32_to_cpu(Header.type);
+ Header.maptype = be32_to_cpu(Header.maptype);
+ Header.maplength = be32_to_cpu(Header.maplength);
bpp = 0;
if (Header.depth == 32)
bpp = 4;
- else
+ if (Header.depth == 24)
bpp = 3;
+ if (Header.depth == 8)
+ bpp = 1;
+
+ printf("mapl %i \n",Header.maplength);
+ if (Header.maplength>0)
+ i = fread(ColorMap,1,Header.maplength,f);
+
g_assert(bpp != 0); /* Only 24 and 32 bpp for now */
- pixels = (guchar *) malloc(Header.width * Header.height * bpp);
+ if (bpp==4)
+ pixels = (guchar *) g_malloc(Header.width * Header.height * 4);
+ else
+ pixels = (guchar *) g_malloc(Header.width * Header.height * 3);
if (!pixels) {
return NULL;
}
*/
Y = 0;
while (Y < Header.height) {
- OneLineBGR(f, Header.width,
- &pixels[Y * Header.width * bpp], bpp);
+ if (bpp>1)
+ OneLineBGR_file(f, Header.width,
+ &pixels[Y * Header.width * bpp], bpp);
+ else
+ OneLineMapped_file(f, Header.width,
+ &pixels[Y * Header.width * 3], bpp,&ColorMap[0]);
Y++;
}
if (bpp == 4)
return gdk_pixbuf_new_from_data(pixels, ART_PIX_RGB, TRUE,
- Header.width,
- Header.height,
- Header.width * bpp,
- free_buffer, NULL);
+ (gint) Header.width,
+ (gint) Header.height,
+ (gint) (Header.width *
+ 4), free_buffer,
+ NULL);
else
return gdk_pixbuf_new_from_data(pixels, ART_PIX_RGB, FALSE,
- Header.width,
- Header.height,
- Header.width * bpp,
- free_buffer, NULL);
+ (gint) Header.width,
+ (gint) Header.height,
+ (gint) (Header.width *
+ 3), free_buffer,
+ NULL);
+}
+
+
+/* Progressive loading */
+
+struct ras_progressive_state {
+ ModulePreparedNotifyFunc prepared_func;
+ ModuleUpdatedNotifyFunc updated_func;
+ gpointer user_data;
+
+ GdkPixbuf *pixbuf; /* Our "target" */
+ guchar *PixelData; /* pointer to the next line */
+ struct rasterfile Header;
+ guint bpp;
+ guint BytesPerLine;
+ guchar *linebuf;
+ guchar *ColorMap;
+ guint BytesInLB;
+ guint LinesDone;
+
+
+
+ gboolean have_header;
+};
+
+/*
+ * func - called when we have pixmap created (but no image data)
+ * user_data - passed as arg 1 to func
+ * return context (opaque to user)
+ */
+
+gpointer
+image_begin_load(ModulePreparedNotifyFunc prepared_func,
+ ModuleUpdatedNotifyFunc updated_func, gpointer user_data)
+{
+ struct ras_progressive_state *context;
+
+ context = g_new0(struct ras_progressive_state, 1);
+
+ context->prepared_func = prepared_func;
+ context->updated_func = updated_func;
+ context->user_data = user_data;
+ context->pixbuf = NULL;
+ context->linebuf = NULL;
+ context->bpp = 0;
+ context->have_header = 0;
+ context->BytesInLB = 0;
+ context->BytesPerLine = 0;
+ context->LinesDone = 0;
+ context->ColorMap = NULL;
+
+ return (gpointer) context;
+}
+
+/*
+ * context - returned from image_begin_load
+ *
+ * free context, unref gdk_pixbuf
+ */
+void image_stop_load(gpointer data)
+{
+ struct ras_progressive_state *context =
+ (struct ras_progressive_state *) data;
+
+ g_return_if_fail(context != NULL);
+
+ if (context->pixbuf)
+ gdk_pixbuf_unref(context->pixbuf);
+
+ if (context->linebuf)
+ g_free(context->linebuf);
+ if (context->ColorMap)
+ g_free(context->ColorMap);
+ g_free(context);
+}
+
+
+/*
+ * context - from image_begin_load
+ * buf - new image data
+ * size - length of new image data
+ *
+ * append image data onto inrecrementally built output image
+ */
+gboolean image_load_increment(gpointer data, guchar * buf, guint size)
+{
+ struct ras_progressive_state *context =
+ (struct ras_progressive_state *) data;
+
+ if ((context->have_header == 0) && (size < 32))
+ return FALSE;
+
+ if (context->have_header == FALSE) {
+ memcpy(&context->Header, buf, 32);
+ buf += 32;
+ size -= 32;
+
+ context->Header.width = be32_to_cpu(context->Header.width);
+ context->Header.height =
+ be32_to_cpu(context->Header.height);
+ context->Header.depth = be32_to_cpu(context->Header.depth);
+ context->Header.length =
+ be32_to_cpu(context->Header.length);
+ context->Header.type = be32_to_cpu(context->Header.type);
+ context->Header.maptype =
+ be32_to_cpu(context->Header.maptype);
+ context->Header.maplength =
+ be32_to_cpu(context->Header.maplength);
+
+ context->bpp = 0;
+ if (context->Header.depth == 32)
+ context->bpp = 4;
+ if (context->Header.depth == 24)
+ context->bpp = 3;
+ if (context->Header.depth == 8)
+ context->bpp = 1;
+
+
+ g_assert(context->bpp != 0); /* Only 24 and 32 bpp for now */
+
+
+ if (context->bpp == 4)
+ context->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, TRUE,
+ 8,
+ (gint)
+ context->Header.
+ width,
+ (gint)
+ context->Header.
+ height);
+ else
+ context->pixbuf =
+ gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
+ (gint) context->Header.width,
+ (gint) context->Header.height);
+
+ /* Use pixbuf buffer to store decompressed data */
+ g_assert(context->pixbuf != NULL);
+ g_assert(context->pixbuf->art_pixbuf != NULL);
+ context->PixelData = context->pixbuf->art_pixbuf->pixels;
+ g_assert(context->PixelData != NULL);
+ context->BytesPerLine =
+ context->Header.width * context->bpp;
+
+ if (((context->BytesPerLine) & 1) != 0) /* Not 16 bit aligned */
+ context->BytesPerLine++;
+
+ context->linebuf =
+ (guchar *) g_malloc(context->BytesPerLine);
+ context->have_header = TRUE;
+ if (context->linebuf == NULL) {
+ /* Failed to allocate memory */
+ g_error("Couldn't allocate linebuf");
+ }
+
+
+ /* Notify the client that we are ready to go */
+ (*context->prepared_func) (context->pixbuf,
+ context->user_data);
+ }
+
+
+ while (size > 0) {
+ guint ToDo;
+ ToDo = context->BytesPerLine - context->BytesInLB;
+ if (ToDo > size)
+ ToDo = size;
+ memcpy(context->linebuf + context->BytesInLB,
+ buf, (size_t) ToDo);
+ size -= ToDo;
+ buf += ToDo;
+ context->BytesInLB += ToDo;
+ if (context->BytesInLB >= context->BytesPerLine) {
+ /* linebuf if full */
+ if (context->bpp>1)
+ OneLineBGR_buf(context->linebuf,
+ context->Header.width,
+ context->PixelData, context->bpp);
+ else
+ OneLineMapped_buf(context->linebuf,
+ context->Header.width,
+ context->PixelData, context->bpp,
+ context->ColorMap);
+ context->BytesInLB = 0;
+ context->PixelData +=
+ context->pixbuf->art_pixbuf->rowstride;
+ context->LinesDone++;
+
+ (*context->updated_func) (context->pixbuf,
+ context->user_data,
+ 0,
+ context->LinesDone,
+ context->Header.width,
+ context->Header.height);
+
+
+ }
+
+ }
+
+ return TRUE;
}
+
projects / gtk4.git / commitdiff